/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.cip.esymons.eventos.bc;

import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.cip.esymons.eventos.be.Preevento;
import org.cip.esymons.general.bc.UsuarioWebFacadeLocal;
import org.cip.esymons.general.be.UsuarioWeb;
import org.cip.esymons.tramite.bc.ExpedienteFacadeLocal;
import org.cip.esymons.tramite.bc.TramiteFacadeLocal;
import org.cip.esymons.tramite.bc.TransaccionFacadeLocal;
import org.cip.esymons.tramite.be.Expediente;
import org.cip.esymons.tramite.be.Tramite;
import org.cip.esymons.tramite.be.Transaccion;

/**
 *
 * @author OscarA
 */
public class PreEventoDelegate {

    PreeventoFacadeLocal local;
    ExpedienteFacadeLocal localExpediente;      //Lizardo: para integrar con tramite
    TransaccionFacadeLocal localTransaccion;    //Lizardo: para integrar con tramite
    TramiteFacadeLocal localTramite;            //Lizardo: para integrar con tramite
    UsuarioWebFacadeLocal localUsuario;         //Lizardo: para integrar con tramite

    public PreEventoDelegate() {
        local = lookupPreeventoFacade();
        localExpediente = lookupExpedienteFacade();
        localTransaccion = lookupTransaccionFacade();   //Lizardo: para integrar con tramite
        localTramite = lookupTramiteFacade();           //Lizardo: para integrar con tramite
        localUsuario = lookupUsuarioWebFacadeLocal();   //Lizardo: para tomar datos del usuario
    }

    public void actualizar(Preevento preEventoSeleccionado) throws Exception {
        local.edit(preEventoSeleccionado);
    }

    public List<Preevento> listarDesaprobadosPresupuesto() throws Exception {
        return local.listarPreEventos_Presupuesto();
    }

    public List<Preevento> listarEventosAprobados() throws Exception{
        return local.listarPreEventos_Aprobados();
    }

    public List<Preevento> listarEventosPorTramitar() {
        return local.listaPreEventosPorTramitar();
    }

    public List<Preevento> listarPermitosModificarPresupuesto() {
        return local.listarPermitosModificarPresupuesto();
    }

    public List<Preevento> listarVerificarContenidos() {
        return local.listarVerificarContenidos();
    }

    public List<Preevento> listarVerificarPresupuesto() {
        return local.listarVerificarPresupuesto();
    }

    public List<Preevento> listarTodosxUsuarios() throws Exception {
        return local.listarPreEventosxUsuario();
    }

    public List<PreeventoAdapter> listarPreEventos_Cursos() {
        return local.listarPreEventos_Cursos();
    }

    public PreeventoAdapter buscarPorCodigo(Object id) {
        return local.buscarPorCodigo(id);
    }

    public void registrar(Preevento preEvento) throws Exception {
        local.create(preEvento);
    }

    //Lizardo Rios
    public List<Preevento> listaEventos() {
        return local.listaEventos();
    }

    //Lizardo Rios
    public List<Preevento> listaEventosSinCurso() throws Exception {
        return local.listaEventosSinCurso();
    }

    //Lizardo Rios
    public List<Preevento> listaEventosConCurso() throws Exception {
        return local.listaEventosConCurso();
    }

    //Lizardo Rios
    public Preevento findID(Object id) {
        return local.find(id);
    }

    //Lizardo Rios
    public List<Preevento> findAll() throws Exception {
        return local.findAll();
    }

    //Lizardo Rios
    public List<Preevento> listarCursos() {
        return local.listarCursos();
    }

    //Lizardo Rios
    public List<Preevento> listarPreeventosActivos() {
        return local.listarPreeventosActivos();
    }

    private PreeventoFacadeLocal lookupPreeventoFacade() {
        try {
            Context c = new InitialContext();
            return (PreeventoFacadeLocal) c.lookup("java:comp/env/PreeventoFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    /*
     *  Metodos para registrar transacciones en el modulo de tramites
     */

    public void registrarTransaccion(Transaccion transaccion) throws Exception {
        localTransaccion.create(transaccion);
    }

    private TransaccionFacadeLocal lookupTransaccionFacade() {
        try {
            Context c = new InitialContext();
            return (TransaccionFacadeLocal) c.lookup("java:comp/env/TransaccionFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public Tramite buscarNombreTramite(String nombre) throws Exception {
        return localTramite.buscarXNombre(nombre);
    }

    private TramiteFacadeLocal lookupTramiteFacade() {
        try {
            Context c = new InitialContext();
            return (TramiteFacadeLocal) c.lookup("java:comp/env/TramiteFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    public void RegistrarExpediente(Expediente expediente) throws Exception {
        localExpediente.create(expediente);
    }

    private ExpedienteFacadeLocal lookupExpedienteFacade() {
        try {
            Context c = new InitialContext();
            return (ExpedienteFacadeLocal) c.lookup("java:comp/env/ExpedienteFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

    //Usuario Web
    private UsuarioWeb buscarUsuario(String cuenta) throws Exception {
        return localUsuario.buscarUsuario(cuenta);
    }    

    private UsuarioWebFacadeLocal lookupUsuarioWebFacadeLocal() {
        try {
            Context c = new InitialContext();
            return (UsuarioWebFacadeLocal) c.lookup("java:comp/env/UsuarioWebFacade");
        } catch (NamingException ne) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", ne);
            throw new RuntimeException(ne);
        }
    }

}
